import 'dart:async';
import 'package:interview/config/device.dart';
import 'package:interview/config/network.dart';
import 'package:interview/utils/logger.dart';

class Task {
  int priority; // 任务优先级，值越小优先级越高
  final Future<void> Function() execute; // 任务执行函数
  final String name; // 任务名称
  final DateTime timestamp; // 任务添加时间

  Task(this.priority, this.execute, this.name) : timestamp = DateTime.now();

  @override
  String toString() {
    return '任务名: $name, 优先级: $priority, 添加时间: $timestamp';
  }
}


class TaskQueue {
  final List<Task> taskQueue = []; // 任务队列
  int runningTasks = 0;  // 当前正在运行的任务数
  int maxConcurrentTasks = 2; // 默认最大并发数
  final Duration lowPriorityTimeout = Duration(seconds: 10); // 优先级提升阈值
  final Map<Task, DateTime> taskWaitTimes = {}; // 记录任务加入队列的时间
  final network = Network();
  final device = Device();
  

  // 添加任务到队列
  void addTask(Task task) {
    taskQueue.add(task); // 将任务加入队列
    taskWaitTimes[task] = DateTime.now(); // 记录任务加入时间
    // processQueue(); // 开始处理任务队列  交给业务层去触发 
  }
  

  void processQueue() {
    if (taskQueue.isEmpty) return;
    // 动态调整优先级
    _adjustPriorities();
    // 按优先级排序队列
    taskQueue.sort((a, b) {
      if(a.priority == b.priority){
        return a.timestamp.compareTo(b.timestamp);
      }
      return a.priority.compareTo(b.priority);
    });
    // 执行任务
    while (runningTasks < maxConcurrentTasks && taskQueue.isNotEmpty) {
      final Task task = taskQueue.removeAt(0); // 取出优先级最高的任务
      runningTasks++;
      task.execute().then((_) {
        runningTasks--;
        processQueue(); // 执行下一个任务
      });
    }
  }

  // 动态提升低优先级任务的优先级
  void _adjustPriorities() {
    final DateTime now = DateTime.now();
    for (final task in taskQueue) {
      final DateTime? waitTime = taskWaitTimes[task];
      // 如果任务等待时间超过设定的 lowPriorityTimeout（如 10 秒），则提升优先级。
      if (waitTime != null && now.difference(waitTime) > lowPriorityTimeout) {
        // 动态提升优先级
        task.priority = task.priority > 1 ? task.priority - 1 : 1;
        Logger.info("任务优先级提升: $task", tag: "_adjustPriorities");
      }
    }
  }

  // 动态检测设备能力和网络状态，并更新 maxConcurrentTasks
  Future<void> updateMaxConcurrentTasks() async {
    final int deviceCapability = await _detectDeviceCapabilities();
    final int networkCapability = await _detectNetworkConditions();
    // 使用较低的并发数作为最终的 maxConcurrentTasks
    maxConcurrentTasks = deviceCapability < networkCapability  ? deviceCapability : networkCapability;
  }

 
  // 检测设备能力（内存大小 CPU 核心数）
  Future<int> _detectDeviceCapabilities() async {
    final res = await device.shouldLimitConcurrency();
    return res ? 3 : 6;
  }

  // 检测网络状态
  Future<int> _detectNetworkConditions() async {
    final isWifi = network.isWiFi();
    final isMobileData = network.isMobileData();
    // 根据网络条件动态调整并发数
    if (isMobileData) {
      return 3; // 移动网络，限制并发数
    } else if (isWifi) {
      return 6; // Wi-Fi 网络，允许更高并发数
    } else {
      return 3; // 无网络或其他条件
    }
  }
}
